package thread;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: wx
 * Date: 2024-01-03
 * Time: 17:12
 */

// synchronized 加锁的效果,也可以称为 "互斥性"
public class ThreadDemo20 {
    public static void main(String[] args) {

    }
    public static void main1(String[] args) {                   //他的特性就是 "可重入锁"
                                                               //这个代码,直观看起来好像是有锁冲突的.
        Object locker = new Object();
        Thread t = new Thread(() -> {
            synchronized (locker) {
                synchronized (locker) {                        //此时的locker已经处于加锁状态了,在对其进行加锁,不就会出现"阻塞"情况吗?
                    System.out.println("hello !!!");           //为什么没有出现阻塞呢?
                }                                              //是因为两次加锁,是同一个线程在进行的!!!
                                                               //当前由于是同一个线程加锁,此时锁对象,就知道了第二次加锁的线程,就是持有锁的线程.
                                                               //第二次操作,就可以直接放行通过,不会出现阻塞.
            }                                                  //不是同一个线程的时候,其他线程,加锁失败,阻塞等待
            //应该在这里解锁. 避免 1 和 2 之间的逻辑,失去保护          //本身持有锁的这个线程,再次加锁,应该是能够加上的
            //最外层{ 进行加锁 ; 最外层 } 进行解锁
        });
                                               //对于可重入锁 内部会持有两个信息
                                               //1.当前锁是被那个线程持有的
                                               //2.加锁次数的计数器
                                                        //并不是两个锁都释放,一共只有一把锁 (一个锁对象,只有一把锁)
        t.start();
        //这行代码,如果运行,能否打印 hello? 可以运行.
        //会不会有问题?
        //背后如何运行??
                       /*这个加锁过程中,在第一次真正加锁,同时把计数器 + 1 (初始情况是 0 , +1 之后变成 1 了,说明当前这个对象被该线程加锁一次)同时记录线程是谁
                         判定当前加锁线程是否是持有锁的线程,如果不是一个线程,阻塞等待,如果是同一个线程,就只是 ++ 计数器即可,并没有别的操作了*/
    }

}
